#!/usr/bin/python
#
# Copyright (C) 2007, 2009 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

__author__ = 'Gunjan Sharma <gunjansharma@google.com>'

from __future__ import print_function
import getopt
import getpass
import sys
import time
import atom
import atom.data
import gdata.apps.multidomain.client
import gdata.apps.organization.service
import gdata.apps.service
import gdata.client
import gdata.contacts.client
import gdata.contacts.data
import gdata.contacts.service
import gdata.sites.client
import gdata.sites.data

#The title for the site
ORG_SITE_TITLE = 'Organization Hierarchy'
#Title for the users site
USER_SITE_TITLE = 'Users'
#The template URI for a site
URI = 'https://sites.google.com/a/%s/%s/'
#Description for the sites
DESCRIPTION = 'Under Construction'
#Theme for the sites
THEME = 'slate'
#Header for the new webpages
HTML_HEADER = ('<html:div xmlns:html="http://www.w3.org/1999/xhtml">'
               '<html:table cellspacing="0" class='
               '"sites-layout-name-one-column sites-layout-hbox"><html:tbody>'
               '<html:tr><html:td class="sites-layout-tile '
               'sites-tile-name-content-1">')
#Footer for the new webpages
HTML_FOOTER = '</html:td></html:tr></html:tbody></html:table></html:div>'
#The template string for each user's html page
TEMPLATE_USER_HTML = ('<h2>Name:</h2><p>%s</p><h2>Gender:</h2><p> %s</p>'
                      '<h2>Address:</h2><p>%s</p><h2>Email:</h2><p>%s</p>')


class OrgUnitAddressBook(object):
  """Creates organization unit sites from the domain."""

  def __init__(self, email, password, domain):
    """Constructor for the OrgUnitSites object.

    Takes an email, password and domain to create a site map corresponding
    to the organization units in the domain.

    Args:
      email: [string] The email address of the admin.
      password: [string] The password corresponding to the admin account.
      domain: [string] The domain for which sites are to be made.

    Returns:
      A OrgUnitSites object used to run the site making.
    """
    source = 'Making sites corresponding to org units'
    self.domain = domain
    # Create sites object
    self.sites_client = gdata.sites.client.SitesClient(source=source,
                                                       domain=domain)
    self.sites_client.ClientLogin(email, password, self.sites_client.source);
    #Get the sites feed
    self.all_site_feed = self.sites_client.GetSiteFeed()

    # Create google contacts object
    self.profiles_client = gdata.contacts.client.ContactsClient(domain=domain)
    self.profiles_client.client_login(email, password, 'cp', service='cp')

    # Create an Organization Unit Client
    self.org_unit_client = gdata.apps.organization.service.OrganizationService(
                                 email=email, domain=domain, password=password)
    self.org_unit_client.ProgrammaticLogin()
    customer_id_set = self.org_unit_client.RetrieveCustomerId()
    self.customer_id = customer_id_set['customerId']

  def _GetSiteName(self, site_title):
    """Returns the corresponding site_name. This is needed since the site name
       isn't the same as the title.

    Args:
      site_title: [string] The title for a site.

    Returns:
      A string which is the corresponding site_name.
    """
    site_name = site_title.replace(' ', '-')
    site_name = site_name.lower()
    return site_name

  def _GetSiteURI(self, site_title):
    """Returns the corresponding uri to the site.
       Needed to get the link to a particular user page.

    Args:
      site_title: [string] The title for a site.

    Returns:
      A string which is the corresponding site's URI.
    """
    uri = URI % (self.domain, self._GetSiteName(site_title))
    return uri

  def _CreateSite(self, site_title, description=DESCRIPTION, theme=THEME):
    """Creates a site with the site_title, if it not already exists.

    Args:
      site_title: [string] The title for a site.
      description: [string] The description for the site.
      theme: [string] The theme that should be set for the site.

    Returns:
      A Content feed object for the created site.
    """
    site_entry = None
    site_found = False
    site_name = self._GetSiteName(site_title)
    for site in self.all_site_feed.entry:
      if site.site_name.text == site_name:
        site_found = True
        site_entry = site
        break
    if site_found == False:
      try:
        site_entry = self.sites_client.CreateSite(site_title,
                          description=description, theme=theme)
      except gdata.client.RequestError as error:
        print(error)
    self.sites_client.site = site_name
    return site_entry

  def _DeleteAllPages(self):
    '''Deletes all the pages in a site except home'''
    feed_uri = self.sites_client.make_content_feed_uri()
    while feed_uri:
      feed = self.sites_client.GetContentFeed()
      for entry in feed.entry:
        if entry.page_name.text != 'home':
          self.sites_client.Delete(entry)
      feed_uri = feed.FindNextLink()

  def _GetUsersProfileFeed(self):
    """Retrieves all the user's profile.

    Returns:
      A Dictionary of email address to ContentEntry objects
    """
    profiles = []
    feed_uri = self.profiles_client.GetFeedUri('profiles')
    while feed_uri:
      feed = self.profiles_client.GetProfilesFeed(uri=feed_uri)
      profiles.extend(feed.entry)
      feed_uri = feed.FindNextLink()

    profiles_dict = {}
    for profile in profiles:
      for email in profile.email:
        if email.primary and email.primary == 'true':
          profiles_dict[email.address] = profile
          break

    return profiles_dict

  def _CreateUserPageHTML(self, profile):
    """Creates HTML for a user profile.

    Args:
      profile: [gdata.contacts.data.ProfileEntry] It is the profile of the user
                                                  whose HTML has to be created.

    Returns:
      A String which is the HTML code.
    """
    address_string = ''
    email_string = ''
    for address in profile.structured_postal_address:
      address_string = '%s<li>%s</li><br />' % (address_string, address)
    for email in profile.email:
      if email.primary and email.primary == 'true':
        email_string = '%s<li>%s</li><br />' % (email_string, email.address)

    new_html = TEMPLATE_USER_HTML % (profile.name.full_name.text,
                         str(profile.gender), address_string, email_string)

    return HTML_HEADER + new_html + HTML_FOOTER

  def _GetUserPageName(self, user_email):
    """Creates a page name for a particular user depending on the
       email address.

    Args:
      user_email: [string] The email address of the user.

    Returns:
      A String which defines the user page name.
    """
    user_page_name = user_email.replace('@', '-')
    user_page_name = user_page_name.replace('.', '_')
    user_page_name = user_page_name.lower()
    return user_page_name

  def _CreateUserPages(self):
    """Makes all the user pages"""

    entry = self._CreateSite(USER_SITE_TITLE)

    #Delete all the pages
    self._DeleteAllPages()

    users_profile = self._GetUsersProfileFeed()
    users = self.org_unit_client.RetrieveAllOrgUsers(self.customer_id)
    for user in users:
      user_email = user['orgUserEmail']
      user_profile = users_profile[user_email]
      new_html = self._CreateUserPageHTML(user_profile)
      user_page_name = self._GetUserPageName(user_email)

      self.sites_client.CreatePage('webpage', user_profile.name.full_name.text,
                                   html=new_html, page_name=user_page_name)

  def _GetOrgUnitPageHTML(self, path):
    """Creates HTML for a Org Unit Page.

    Args:
      profile: [string] Path of the Org Unit.

    Returns:
      A String which is the HTML code.
    """

    domain_users = self.org_unit_client.RetrieveOrgUnitUsers(self.customer_id,
                                                             path)
    new_html = '<p>'
    for user in domain_users:
      user_email = user['orgUserEmail']
      user_page_name = self._GetUserPageName(user_email)
      site_uri = self._GetSiteURI(USER_SITE_TITLE)
      new_html = '%s<li><a href="%s">%s</a></li><br />' % (new_html,
                                         site_uri + user_page_name, user_email)
    new_html = new_html + '</p>'
    return HTML_HEADER + new_html + HTML_FOOTER

  def _SetOrgSiteHomePage(self):
    """Sets up the home page for Org Unit Site"""
    new_html = self._GetOrgUnitPageHTML('/')
    home_path = self._GetUnitPath()
    home_feed = self.sites_client.GetContentFeed(uri=home_path)
    home_feed.entry[0].title.text = self.domain
    home_feed.entry[0].content.html = new_html
    self.sites_client.Update(home_feed.entry[0])

  def _GetUnitPath(self, path=None):
    """Returns path to the parent unit

    Args:
      parent_path: [string] Path of the Parent Org Unit.

    Returns:
      A String which is the path to the parent.
    """
    path_uri = '%s?path=/%s'
    if path:
      path = path.replace('+', '-')
      path = path.lower()
      path = 'home/' + path
    else:
      path = 'home'

    uri = path_uri % (self.sites_client.MakeContentFeedUri(), path)
    return uri

  def _CreateOrgUnitPages(self):
    """Creates all the org unit pages"""

    entry = self._CreateSite(ORG_SITE_TITLE)
    #Delete all the pages
    self._DeleteAllPages()

    self._SetOrgSiteHomePage()

    orgUnits = self.org_unit_client.RetrieveAllOrgUnits(self.customer_id)
    for unit in orgUnits:
      parent_uri = self._GetUnitPath(unit['parentOrgUnitPath'])
      parent_feed = self.sites_client.GetContentFeed(uri=parent_uri)

      new_html = self._GetOrgUnitPageHTML(unit['orgUnitPath'])
      self.sites_client.CreatePage('webpage', unit['name'], html=new_html,
                                   parent=parent_feed.entry[0])

  def Run(self):
    """Controls the entire flow of the sites making process"""

    print('Starting the process. This may take few minutes.')
    print('Creating user pages...')
    self._CreateUserPages()
    print('User pages created')
    print('Creating Organization Unit Pages')
    self._CreateOrgUnitPages()
    print('Your website is ready, visit it at: %s' % (self._GetSiteURI(
                                                      ORG_SITE_TITLE)))


def main():
  """Runs the site making module using an instance of OrgUnitAddressBook"""
  # Parse command line options
  try:
    opts, args = getopt.getopt(sys.argv[1:], '', ['email=', 'pw=', 'domain='])
  except getopt.error as msg:
    print ('python org_unit_sites.py --email [emailaddress] --pw [password]'
           ' --domain [domain]')
    sys.exit(2)

  email = ''
  password = ''
  domain = ''
  # Parse options
  for option, arg in opts:
    if option == '--email':
      email = arg
    elif option == '--pw':
      password = arg
    elif option == '--domain':
      domain = arg

  while not email:
    email = input('Please enter admin email address (admin@example.com): ')
  while not password:
    sys.stdout.write('Admin Password: ')
    password = getpass.getpass()
    if not password:
      print('Password cannot be blank.')
  while not domain:
    username, domain = email.split('@', 1)
    choice = input('You have not given us the domain name. ' +
                        'Is it %s? (y/n)' % (domain))
    if choice == 'n':
      domain = input('Please enter domain name (domain.com): ')

  try:
    org_unit_address_book = OrgUnitAddressBook(email, password, domain)
  except gdata.service.BadAuthentication:
    print('Invalid user credentials given.')
    return

  org_unit_address_book.Run()


if __name__ == '__main__':
  main()
